spring boot 源码解析28-Log4J2LoggingSystem

最新推荐文章于 2024-08-14 11:39:49 发布
最新推荐文章于 2024-08-14 11:39:49 发布
阅读量1.3w 收藏 1
点赞数 2
分类专栏： spring boot spring boot 源码解析 文章标签： spring 源码 log4j class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26000415/article/details/79109517
版权

前言

spring boot 中关于Log的实现我们已经分析了JavaLoggingSystem,本文就来看看Log4J2LoggingSystem,在分析之前,我们需要先分析一下Slf4JLoggingSystem–> Log4J2LoggingSystem,LogbackLoggingSystem 的父类.

解析

Slf4JLoggingSystem

  1. 字段,构造器如下:

    private static final String BRIDGE_HANDLER = "org.slf4j.bridge.SLF4JBridgeHandler";

public Slf4JLoggingSystem(ClassLoader classLoader) {
    super(classLoader);
}

  2. 覆写了如下方法:

    1. beforeInitialize,代码如下:

      public void beforeInitialize() {
    super.beforeInitialize();
    // 1. 配置SLF4JBridgeHandler
    configureJdkLoggingBridgeHandler();
}

      configureJdkLoggingBridgeHandler–>配置SLF4JBridgeHandler 代码如下:

      private void configureJdkLoggingBridgeHandler() {
    try {
        // 1. 如果在当前类路径下存在org.slf4j.bridge.SLF4JBridgeHandler,则
        if (isBridgeHandlerAvailable()) {
            // 1.1 删除slf4j 中root logger 配置的所有handler
            removeJdkLoggingBridgeHandler();
            // 1.2 为root logger添加SLF4JBridgeHandler
            SLF4JBridgeHandler.install();
        }
    }
    catch (Throwable ex) {
        // Ignore. No java.util.logging bridge is installed.
    }
}

      1. 如果在当前类路径下存在org.slf4j.bridge.SLF4JBridgeHandler,则

        1. 删除slf4j 中root logger 配置的所有handler,代码如下:

          private void removeJdkLoggingBridgeHandler() {
    try {
        if (isBridgeHandlerAvailable()) {
            try {
                SLF4JBridgeHandler.removeHandlersForRootLogger();
            }
            catch (NoSuchMethodError ex) {
                // Method missing in older versions of SLF4J like in JBoss AS 7.1
                SLF4JBridgeHandler.uninstall();
            }
        }
    }
    catch (Throwable ex) {
        // Ignore and continue
    }
}

        2. 为root logger添加SLF4JBridgeHandler,代码如下:

          public static void install() {
    LogManager.getLogManager().getLogger("").addHandler(new SLF4JBridgeHandler());
}

    2. cleanUp–>删除slf4j 中root logger 配置的所有handler,代码如下:

      public void cleanUp() {
    removeJdkLoggingBridgeHandler();
}

    3. loadConfiguration–>设置系统属性,代码如下:

      protected void loadConfiguration(LoggingInitializationContext initializationContext,
        String location, LogFile logFile) {
    Assert.notNull(location, "Location must not be null");
    if (initializationContext != null) {
        applySystemProperties(initializationContext.getEnvironment(), logFile);
    }
}

      调用父类(AbstractLoggingSystem)中的 applySystemProperties方法,代码如下:

      protected final void applySystemProperties(Environment environment, LogFile logFile) {
    new LoggingSystemProperties(environment).apply(logFile);
}

Log4J2LoggingSystem

  1. 字段如下:

    private static final String FILE_PROTOCOL = "file";

private static final LogLevels<Level> LEVELS = new LogLevels<Level>();

static {
    LEVELS.map(LogLevel.TRACE, Level.TRACE);
    LEVELS.map(LogLevel.DEBUG, Level.DEBUG);
    LEVELS.map(LogLevel.INFO, Level.INFO);
    LEVELS.map(LogLevel.WARN, Level.WARN);
    LEVELS.map(LogLevel.ERROR, Level.ERROR);
    LEVELS.map(LogLevel.FATAL, Level.FATAL);
    LEVELS.map(LogLevel.OFF, Level.OFF);
}

//  在beforeInitialize中添加该filter,目的是log4j2 没有初始化完毕时是不能使用的,此时所有的处理都是DENY,就不会打印日志了
private static final Filter FILTER = new AbstractFilter() {

    @Override
    public Result filter(LogEvent event) {
        return Result.DENY;
    }

    @Override
    public Result filter(Logger logger, Level level, Marker marker, Message msg,
            Throwable t) {
        return Result.DENY;
    }

    @Override
    public Result filter(Logger logger, Level level, Marker marker, Object msg,
            Throwable t) {
        return Result.DENY;
    }

    @Override
    public Result filter(Logger logger, Level level, Marker marker, String msg,
            Object... params) {
        return Result.DENY;
    }

};

public Log4J2LoggingSystem(ClassLoader classLoader) {
    super(classLoader);
}

  2. 方法如下:

    1. getStandardConfigLocations –> 获取配置文件,代码如下:

      protected String[] getStandardConfigLocations() {
    return getCurrentlySupportedConfigLocations();
}

      调用: 

      private String[] getCurrentlySupportedConfigLocations() {
    List<String> supportedConfigLocations = new ArrayList<String>();
    // 1. 如果当前类路径下存在com.fasterxml.jackson.dataformat.yaml.YAMLParser,则加入log4j2.yaml,log4j2.yml,默认情况下不支持
    if (isClassAvailable("com.fasterxml.jackson.dataformat.yaml.YAMLParser")) {
        Collections.addAll(supportedConfigLocations, "log4j2.yaml", "log4j2.yml");
    }
    // 2. 如果当前类路径下存在com.fasterxml.jackson.databind.ObjectMapper,则加入log4j2.json,log4j2.jsn
    if (isClassAvailable("com.fasterxml.jackson.databind.ObjectMapper")) {
        Collections.addAll(supportedConfigLocations, "log4j2.json", "log4j2.jsn");
    }
    // 3. 默认加入log4j2.xml
    supportedConfigLocations.add("log4j2.xml");
    return supportedConfigLocations
            .toArray(new String[supportedConfigLocations.size()]);
}
      1. 如果当前类路径下存在com.fasterxml.jackson.dataformat.yaml.YAMLParser,则加入log4j2.yaml,log4j2.yml,默认情况下不支持
      2. 如果当前类路径下存在com.fasterxml.jackson.databind.ObjectMapper,则加入log4j2.json,log4j2.jsn
      3. 默认加入log4j2.xml

      因此,默认情况下返回的是log4j2.json, log4j2.jsn, log4j2.xml

    2. beforeInitialize,代码如下:

      public void beforeInitialize() {
    LoggerContext loggerContext = getLoggerContext();
    if (isAlreadyInitialized(loggerContext)) {
        return;
    }
    super.beforeInitialize();
    loggerContext.getConfiguration().addFilter(FILTER);
}
      1. 获得LoggerContext,如果LoggerContext中的ExternalContext 存放的是org.springframework.boot.logging.LoggingSystem,则意味着已经初始化过了,此时直接return
      2. 调用父类的beforeInitialize,配置SLF4JBridgeHandler
      3. 添加FILTER,目的是log4j2 没有初始化完毕时是不能使用的,此时所有的处理都是DENY,就不会打印日志了

    3. initialize,代码如下:

      public void initialize(LoggingInitializationContext initializationContext,
        String configLocation, LogFile logFile) {
    // 1. 获得LoggerContext,如果LoggerContext中的ExternalContext 存放的是org.springframework.boot.logging.LoggingSystem,
    // 则意味着已经初始化过了,此时直接return
    LoggerContext loggerContext = getLoggerContext();
    if (isAlreadyInitialized(loggerContext)) {
        return;
    }
    // 2. 删除FILTER,此时意味着已经初始化成功了
    loggerContext.getConfiguration().removeFilter(FILTER);
    // 3. 加载配置文件
    super.initialize(initializationContext, configLocation, logFile);
    // 4. 向LoggerContext中的ExternalContext 存放-->org.springframework.boot.logging.LoggingSystem,标记成功初始化
    markAsInitialized(loggerContext);
}
      1. 获得LoggerContext,如果LoggerContext中的ExternalContext 存放的是org.springframework.boot.logging.LoggingSystem,则意味着已经初始化过了,此时直接return
      2. 删除FILTER,此时意味着已经初始化成功了
      3. 加载配置文件

      4. 向LoggerContext中的ExternalContext 存放–>org.springframework.boot.logging.LoggingSystem,标记成功初始化.代码如下:

        private void markAsInitialized(LoggerContext loggerContext) {
    loggerContext.setExternalContext(LoggingSystem.class.getName());
}

    4. loadDefaults–>加载默认的配置文件:

      protected void loadDefaults(LoggingInitializationContext initializationContext,
        LogFile logFile) {
    // 1. 如果logFile 不等于null,则加载org/springframework/boot/logging/log4j2/log4j2-file.xml的配置,默认这步是不会执行的
    if (logFile != null) {
        loadConfiguration(getPackagedConfigFile("log4j2-file.xml"), logFile);
    }
    // 否则,加载org/springframework/boot/logging/log4j2/log4j2.xml
    else {
        loadConfiguration(getPackagedConfigFile("log4j2.xml"), logFile);
    }
}
      1. 如果logFile 不等于null,则加载org/springframework/boot/logging/log4j2/log4j2-file.xml的配置,默认这步是不会执行的
      2. 否则,加载org/springframework/boot/logging/log4j2/log4j2.xml

      loadConfiguration实现如下:

      protected void loadConfiguration(String location, LogFile logFile) {
    Assert.notNull(location, "Location must not be null");
    try {
        // 1. 获得LoggerContext
        LoggerContext ctx = getLoggerContext();
        // 2.将location转换为URL
        URL url = ResourceUtils.getURL(location);
        // 3.根据url 获得对应的ConfigurationSource
        ConfigurationSource source = getConfigurationSource(url);
        // 4. 启动
        ctx.start(ConfigurationFactory.getInstance().getConfiguration(ctx, source));
    }
    catch (Exception ex) {
        throw new IllegalStateException(
                "Could not initialize Log4J2 logging from " + location, ex);
    }
}
      1. 获得LoggerContext
      2. 将location转换为URL

      3. 根据url 获得对应的ConfigurationSource.代码如下:

        private ConfigurationSource getConfigurationSource(URL url) throws IOException {
    InputStream stream = url.openStream();
    if (FILE_PROTOCOL.equals(url.getProtocol())) {// 如果是file协议
        return new ConfigurationSource(stream, ResourceUtils.getFile(url));
    }
    // 2. 其他,由于当前是classpath 协议,因此会执行到这里
    return new ConfigurationSource(stream, url);
}
      4. 启动

    5. reinitialize –>调用时机:在log4j初始化时,在类路径下加载的以下任一1个配置文件:log4j2.json, log4j2.jsn, log4j2.xml,通过LogFile等于null,则调用该方法.代码如下:

      protected void reinitialize(LoggingInitializationContext initializationContext) {
    getLoggerContext().reconfigure();
}

      log4j 不会直接删除所有的Loggers在重新配置的阶段,而是会重新创建LoggerConfig,然后进行替换.旧的LoggerConfig,Appenders，Filters 会被释放

    6. setLogLevel.代码如下:

      public void setLogLevel(String loggerName, LogLevel logLevel) {
    // 1. 转换LogLevel 为log4j2的LogLevel
    Level level = LEVELS.convertSystemToNative(logLevel);
    // 2.根据loggerName 获得对应的LoggerConfig
    LoggerConfig loggerConfig = getLoggerConfig(loggerName);
    // 3. 如果不存在对应的LoggerConfig,则进行添加,否则直接进行修改
    if (loggerConfig == null) {
        loggerConfig = new LoggerConfig(loggerName, level, true);
        getLoggerContext().getConfiguration().addLogger(loggerName, loggerConfig);
    }
    else {
        loggerConfig.setLevel(level);
    }
    // 4. 更新
    getLoggerContext().updateLoggers();
}
      1. 转换LogLevel 为log4j2的LogLevel
      2. 根据loggerName 获得对应的LoggerConfig
      3. 如果不存在对应的LoggerConfig,则进行添加,否则直接进行修改
      4. 更新

    7. getLoggerConfigurations –> 获得所有的配置文件.代码如下:

      public List<LoggerConfiguration> getLoggerConfigurations() {
    List<LoggerConfiguration> result = new ArrayList<LoggerConfiguration>();
    Configuration configuration = getLoggerContext().getConfiguration();
    for (LoggerConfig loggerConfig : configuration.getLoggers().values()) {
        result.add(convertLoggerConfiguration(loggerConfig));
    }
    Collections.sort(result, CONFIGURATION_COMPARATOR);
    return result;
}
      1. 获得Configuration中配置的Logger,遍历之

      2. 将LoggerConfig 转换为LoggerConfiguration.代码如下:

        private LoggerConfiguration convertLoggerConfiguration(LoggerConfig loggerConfig) {
    if (loggerConfig == null) {
        return null;
    }
    LogLevel level = LEVELS.convertNativeToSystem(loggerConfig.getLevel());
    String name = loggerConfig.getName();
    if (!StringUtils.hasLength(name) || LogManager.ROOT_LOGGER_NAME.equals(name)) {
        name = ROOT_LOGGER_NAME;
    }
    return new LoggerConfiguration(name, level, level);
}
        1. 如果LoggerConfig等于null,则返回null
        2. 将log4j配置的日志级别转换为LogLevel
        3. 如果logger的名字等于root，或者不存在,则将其赋值为root
        4. 实例化LoggerConfiguration
      3. 排序–>将root logger 排在第1位,其他的按照字典顺序排序

    8. getShutdownHandler–>在ShutdownHandler中直接调用LoggerContext的stop方法.代码如下:

      public Runnable getShutdownHandler() {
    return new ShutdownHandler();
}

      ShutdownHandler 代码如下:

      private final class ShutdownHandler implements Runnable {

    @Override
    public void run() {
        getLoggerContext().stop();
    }
}

    9. cleanUp–>调用时机,当spring boot 发出ContextClosedEvent事件时调用,代码如下:

      public void cleanUp() {
    super.cleanUp();
    LoggerContext loggerContext = getLoggerContext();
    markAsUninitialized(loggerContext);
    loggerContext.getConfiguration().removeFilter(FILTER);
}
      1. 调用父类的cleanUp方法,删除rootLogger配置的handler
      2. 获得LoggerContext

      3. 设置ExternalContext 为null,代码如下:

        private void markAsUninitialized(LoggerContext loggerContext) {
    loggerContext.setExternalContext(null);
}
      4. 删除FILTER

Log4J2LoggingSystem 集成

  1. 由于spring boot 默认依赖的logback,因此我们需要去除,修改pom文件如下:

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

  2. 加入 Log4J2LoggingSystem的依赖.pom文件如下:

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

Log4J2LoggingSystem生命周期

  1. 由于SpringBootConfigurationFactory继承了ConfigurationFactory,因此当使用Log4J2LoggingSystem 的时候,由于log还没有初始化,此时先使用DefaultConfiguration,后续会使用指定的配置.代码如下:

    @Plugin(name = "SpringBootConfigurationFactory", category = ConfigurationFactory.CATEGORY)
@Order(0)
public class SpringBootConfigurationFactory extends ConfigurationFactory {

private static final String[] TYPES = { ".springboot" };

@Override
protected String[] getSupportedTypes() {
    return TYPES;
}

@Override
public Configuration getConfiguration(LoggerContext loggerContext,
        ConfigurationSource source) {
    if (source != null && source != ConfigurationSource.NULL_SOURCE) {
        if (LoggingSystem.get(loggerContext.getClass().getClassLoader()) != null) {
            return new DefaultConfiguration();
        }
    }
    return null;
}
}

    当在类路径下存在.springboot结尾的文件,则会调用该类的getConfiguration方法.由于在spring-boot/src/main/resources/ 下,存在log4j2.springboot,因此该类会被执行.其文件内容如下:

    See SpringBootConfigurationFactory

    此时由于传入的ConfigurationSource不等于null,此时传入的是log4j2.springboot,因此会返回DefaultConfiguration

  2. ApplicationStartingEvent事件处理–>执行Log4J2LoggingSystem#beforeInitialize方法.在该方法中会调用Slf4JLoggingSystem#configureJdkLoggingBridgeHandler,会判断org.slf4j.bridge.SLF4JBridgeHandler是否存在,此时由于加入了spring-boot-starter-log4j2,因此加入了jul-to-slf4 jar 包, 该类就是在该包中,因此会执行后续操作,代码如下:

    private void configureJdkLoggingBridgeHandler() {
    try {
        // 1. 如果在当前类路径下存在org.slf4j.bridge.SLF4JBridgeHandler,则
        if (isBridgeHandlerAvailable()) {
            // 1.1 删除slf4j 中root logger 配置的所有handler
            removeJdkLoggingBridgeHandler();
            // 1.2 为root logger添加SLF4JBridgeHandler
            SLF4JBridgeHandler.install();
        }
    }
    catch (Throwable ex) {
        // Ignore. No java.util.logging bridge is installed.
    }
}

  3. ApplicationEnvironmentPreparedEvent–> 最终会调用Log4J2LoggingSystem#initialize.

  4. ApplicationPreparedEvent事件–> 向beanFactory进行注册.

  5. ContextClosedEvent–>执行Log4J2LoggingSystem#cleanUp方法.

  6. jvm退出前,执行Log4J2LoggingSystem注册的ShutdownHandler,将LoggerContext停止掉.代码如下:

    public void run() {
    getLoggerContext().stop();
}
一个努力的码农
关注
专栏目录
log4j 源码解析_log4j2源码分析
weixin_39995280的博客
12-21 1023
目录1.概述1.1.组件概览1.2.灵活的配置1.2.1.插件发现机制1.2.2.插件装配机制1.2.3.配置文件基本元素与对象的映射关系2.属性占位符2.1.概述2.2.Interpolator插值器2.3.默认属性配置3.Logger3.1.配置示例3.2.配置详解3.3.Logger继承机制4.Appender4.1.概述4.2.框架支持的Appender实现4.3.常用Appender详解...
spring boot 2.1.x log4j2 配置
醉后不知天在水，满船清梦压星河
03-29 780
本文通过项目中的日志配置问题，引出并总结一下spring boot 2.1.x 中 log4j2 的配置 现象 在服务器上调试项目的时候，发现日志文件生成的路径有问题，总是找不到日志位置，后来测试发现每次都在当前目录下生成 log/xxx.log 查看项目配置如下： logging.level.com.xxx.yyy=INFO logging.file=log/xxx.log 在resource...
【log4j2源码分析】
u012632105的博客
09-15 100
log4j2源码分析
log4j2远程代码执行漏洞原理与漏洞复现（基于vulhub，保姆级的详细教程）_log4j漏洞复现
最新发布
heike_Ch的博客
08-14 1574
log4j2是2021年底爆出的非常严重的漏洞，可谓是风靡一时，“血洗互联网”，也是安全公司面试的常见题目，我们应该了解这个漏洞的原理及利用方式。如何排查是否受到了攻击？检查日志中是否存在"jndi:ldap://"、"jndi:rmi//"等字符来发现可能的攻击行为，前面复现的过程在payload的构造中都出现了这样的字符串，这是攻击的典型标志。如何对log4j2的攻击进行防御？1.设置log4j2.formatMsgNoLookups=True。
log4j2 源码分析
SAN_YUN的专栏
12-15 424
1.初始化 Logger logger = LogManager.getLogger(MyTest.class); org.apache.logging.log4j.LogManager.getLogger() LoggerContext.start() LoggerContext.reconfigure() LoggerContext.setConfiguration() org.a...
log4j2源码解析（2.2版本）
茄子的博客
07-20 1896
目的 搞懂下面这两行代码到底是怎么打印出日志的 private static final Logger logger=Logger.getLogger(Log4j2Test.class); logger.info(“log4j info”); 完整代码如下 public class Log4j2Test { private static final Logger logger = LogManager.getLogger(Log4j2Test.class); public static v
Log4j2架构分析与实战
lixiaoxiong的专栏
05-08 6643
Log4j2是Log4j的升级版，与之前的版本Log4j 1.x相比、有重大的改进，在修正了Logback固有的架构问题的同时，改进了许多Logback所具有的功能。
log4j2远程代码执行漏洞根本原因分析 | log4j bug 复现
清云逸仙的博客
12-14 2216
一、 背景 近年来技术开源热潮席卷全球，诸多信息领域大厂及开发者争相拥抱开源，将其推上了前所未有的高度。 然而，最近全球知名开源日志组件 Apache Log4j2 被阿里团队曝出严重高危漏洞。该漏洞让黑客不用知道服务器账号，就可以做到如入无人之境，进而对你的服务做任何你可以想象到的破坏。 Apache Log4j2 这一漏洞被称为 " 史诗级 " 高危漏洞，服务器业务（Steam、iCloud、Minecraft 等）被严重影响。尽管后续 Apache ...
Spring Boot 精讲篇——Spring Boot自动配置原理
weixin_48674590的博客
06-24 328
SpringBoot的核心组件模块 首先，我们来简单统计一下SpringBoot核心工程的源码java文件数量： 我们cd到spring-boot-autoconfigure工程根目录下。执行 $ tree | grep -c .java$ 模块 java文件数 spring-boot 551 spring-boot-actuator 423 spring-boot-autoconfigure 783 spring-boot-devtools 169 spring-boot-cli 180 sp
精尽Spring Boot源码分析 - 日志系统
qq_38082146的博客
07-08 242
概述 日志是一个系统必不可缺少的东西，记录了系统运行时的点点滴滴，便于我们了解自己系统的运行状态，在我们使用 Spring Boot 时，默认就已经提供了日志功能，使用Logback作为默认的日志框架。那么，接下来我们依赖来看看 Spring Boot 是如何初始化好日志系统的。 为什么 Spring Boot 默认的日志框架是Logbasck呢？ 因为在spring-boot-starter模块中引入spring-boot-starter-logging模块，该 Starter 引入...
SpringBoot运行流程源码分析------阶段三（Spring Boot外化配置源码解析）
qq_41934990的博客
10-24 722
首先看一下ApplicationArguments接口的具体方法定义及功能介绍。//返回原始未处理的参数（通过application传入的） String [ ] getSourceArgs();//返回所有参数的集合，如参数为：--foo=bar --debug,则返回【"foo","debug"】 Set < String > getOptionNames();//选项参数中是否包含指定名称的参数 boolean containsOption(String name);
SpringBoot中使用log4j进行日志管理示例源码
03-28
SpringBoot中使用log4j进行日志管理示例源码
Log4j2异步写日志源码
06-27
分三类文件，pom通过maven构建所需jar包，log4j2.xml配置文件，TestController.java测试类，使用debug测试效果较明显。
使用 Log4J2 日志系统
ttyy1112的专栏
05-24 377
如果你还没有习惯使用Logback，虽然我认为它确实是一个比Log4j更好的选择，没有关系，让我来告诉你怎么做吧！ 第一、修改下你的Maven配置，exclusive logging starter，add log4j2 starter。 第二、配置文件给你准备好了，你甚至无需了解每一个配置都是干什么用的，拿来改改就好！ 第三、如果你想给你的配置文件来一个特殊的名字，如果你想临时设置一下某些package的日志输出级别，改改属性配置就好了。 拿走不谢！
springboot系类代码：spring-boot-starter-log4j2
BLOG域名:programb.blog.csdn.net
05-20 2158
在应用程序代码中插入日志请求需要相当多的计划和工作。观察显示，大约4%的代码用于日志记录。因此，即使是中等大小的应用程序也会在其代码中嵌入数千条日志语句。考虑到日志语句的数量，管理这些日志语句而不需要手动修改它们就变得非常必要。 Log4j 2的配置可以通过以下4种方式之一完成： 通过XML、JSON、YAML或properties格式编写的配置文件。 以编程方式，通过创建配置工厂和配置实现。 以编程方式，通过调用配置接口中公开的api将组件添加到默认配置中。 以编程方式，通过调用内部记录器类上的方法。 本
在spring boot中log4j2编程式配置（Programmatic Configuration）步骤
云南小伙闯深圳
06-10 1530
其实官网已经说的比较清楚了：https://logging.apache.org/log4j/2.x/manual/customconfig.html 下面根据自己的实践稍微总结一下： 1、编写 自定义ConfigurationFactory 继承自org.apache.logging.log4j.core.config.ConfigurationFactory。命名为CustomCo
spring boot：日志系统源码深度解析
布道
04-30 1831
总所周知，spring boot对各类日志组件进行了集成，使用起来非常便捷，让我们需要定义对应日志框架的配置文件，比如LogBack、Log4j2等，代码内部便可以直接使用。话不多说，接下来让我们来领略spring这块的奥秘吧。 目录 spring如何集成日志组件 LoggingSystem LogFile是什么 LoggingSystem的实例化 logback.xml的加载优先级 ...
springBoot 配置log4j2
weixin_43700342的博客
03-18 148
1，修改pom.xml文件 <!-- 去除spring-boot默认日志依赖包 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</...
Log4J2源码系列(八) -NullConfuguration是什么？用来做什么的呢？
sweetyi的专栏
03-27 253
分析Log4J2中的NullConfiguration的创建时机、作用，以及内部的构造
spring-boot-starter-log4j2 和 spring-boot-starter-logging
08-10
Spring Boot 提供了多种日志框架的starter，其中 `spring-boot-starter-log4j2` 和 `spring-boot-starter-logging` 都是为了简化在 Spring Boot 应用中集成日志管理。 `spring-boot-starter-log4j2` 是一个特定的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值